The present invention relates to electronic data processing, and more specifically concerns the construction of entire application programs solely from small reusable components that can be substituted and reconfigured easily and quickly.
Major application programs, such as word processors, spreadsheets, and computer-aided design programs, are conventionally written as complete, standalone packages. Although the code may actually consist of many smaller modules, each module is purpose-built for the particular application, and the modules are interconnected with each other according to specifications that vary with each project.
Conventional software design methods make it difficult to add new functions to application programs, to upgrade existing functions, and even to fix bugs. Highly trained programmers familiar with the design details of the application must tease out the code to be modified or replaced, and must take great care not to modify other functions inadvertently or to break any of the existing interconnections.
Recent advances in design methodology have alleviated these problems to some degree. Packaging functions used by many programs into dynamic link libraries (.dll) provides a degree of commonality for low-level functions shared among applications in a suite. However, these are purpose-built for specific sets of applications, and are rarely useful for other applications or even for other versions of the same application without at least some modification by expert programmers.
The current trend in application development involves the use of object-oriented or component-based technologies. In the ideal use of this approach, an application is a collection of components, each performing a different task. These components work together to provide the overall functionality of the application. Programmers might write the individual components specifically for the application, or may take them from a library of components provided by a third party. The functionality provided by a component ranges from a simple button in a user interface to an entire spreadsheet. Components can be built in available technologies such as Component Object Model, OpenDoc, and Java Beans.
A programmer constructs an application in these technologies by using a development tool such as Microsoft Visual Basic to choose components and wire up connections among them. The programmer must employ a great deal of skill in understanding the meanings of the different methods of each component and in selecting which methods of each component may call which other components. The resulting application is a network highly dependent upon the particular components chosen, and has an arbitrary and usually complex topology. There is no explicit definition of this topology; one can know how the components work together only by examining the details of the network itself.
Object-oriented languages such as C++ and Java allow the construction of program components and even entire applications by building up hierarchies of classes that incorporate or inherit functions (methods) from more primitive classes at lower levels. Such hierarchies, however, are by nature static and unchangeable. For example, adding one class into a superclass can only be done by a programmer at the source-code level. Removal of a class from its superclass causes unpredictable failures, because there is no way to know in advance which other classes might also use the methods of the removed class.
An emerging trend in application development involves the concept of plug-ins. For example, third-party providers develop programs that plug into internet browsers for performing certain kinds of multimedia files automatically whenever the browser encounters those file types. Plug-ins are relatively easily replaceable and upgradable separately from the main application. However, they provide only a very small portion of the overall function of any application, and they must still be built specially for each application.
Even with the many techniques currently available to the art, the design, coding, maintenance, and enhancement of major application programs involve long, expensive efforts. A change in one part of the program frequently propagates to other parts, requiring further changes, as well as further opportunities for errors. Applications cannot be subsetted for situations where only part of the application's total functionality is needed. Enhancing an application requires replacing substantially all of the original code in an upgrade package. Any of these tasks requires skilled programmers having experience in the software technologies and large amounts of time and effort. Certainly the concepts of allowing users to design or redesign an application to their own tastes, to replace or upgrade parts of an application with third-party components, or to install small fixes in large programs, remain a pipe dream.